main.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>


//*****************************************************************************
// Declarations
//*****************************************************************************

// Driver stage pin mapping.
#define UL    PB0       // UL
#define UH    PB1       // UH
#define VL    PB2       // VL
#define VH    PB3       // VL
#define WL    PB4       // WL
#define WH    PB5       // WH

#define EDGE_FALLING 1 // Zero crossing polarity flag value for falling zero crossing.
#define EDGE_RISING  0 // Zero crossing polarity flag value for rinsing zero crossing.

#define UPPER_DRIVE_MASK      ((1 << UH) | (1 << VH) | (1 << WH))

#define UPPER_DRIVE_STEP1_CW      (1 << VH) // Drive pattern for commutation step 1, CW rotation.
#define UPPER_DRIVE_STEP2_CW      (1 << UH) // Drive pattern for commutation step 2, CW rotation.
#define UPPER_DRIVE_STEP3_CW      (1 << UH) // Drive pattern for commutation step 3, CW rotation.
#define UPPER_DRIVE_STEP4_CW      (1 << WH) // Drive pattern for commutation step 4, CW rotation.
#define UPPER_DRIVE_STEP5_CW      (1 << WH) // Drive pattern for commutation step 5, CW rotation.
#define UPPER_DRIVE_STEP6_CW      (1 << VH) // Drive pattern for commutation step 6, CW rotation.


#define LOWER_DRIVE_STEP1_CW      (1 << WL) // Drive pattern for commutation step 1, CW rotation.
#define LOWER_DRIVE_STEP2_CW      (1 << WL) // Drive pattern for commutation step 2, CW rotation.
#define LOWER_DRIVE_STEP3_CW      (1 << VL) // Drive pattern for commutation step 3, CW rotation.
#define LOWER_DRIVE_STEP4_CW      (1 << VL) // Drive pattern for commutation step 4, CW rotation.
#define LOWER_DRIVE_STEP5_CW      (1 << UL) // Drive pattern for commutation step 5, CW rotation.
#define LOWER_DRIVE_STEP6_CW      (1 << UL) // Drive pattern for commutation step 6, CW rotation.

// Loop Compensation
#define HALF_LIMIT 0x7FFFu
#define LOOP_SCALING 3u

// Input command Pin
#define CMD_PIN PA4 // PWM or UART input command
#define CMD_PIN_TEST (PINA & (1<<CMD_PIN)) // Test command pin
#define CMD_PIN_0  (1<<CMD_PIN)  // Test for pin low (inverted circuitry)
#define CMD_PIN_1 0  // Test for pin high (inverted circuitry)


// TACH and Alarm Pin
#define TACH_PIN PA0  //PA0
#define TACH_PIN_0  PORTA |= (1<<TACH_PIN)  //inverted for Configurable BLDC Fan Board
#define TACH_PIN_1  PORTA &= ~(1<<TACH_PIN)  //inverted for Configurable BLDC Fan Board

// Test Pin
#define TEST_PIN  PA3  //PA3
#define TEST_PIN_0  PORTA &= ~(1<<TEST_PIN)
#define TEST_PIN_1  PORTA |= (1<<TEST_PIN)

// LED Pin
#define LED_PIN  PB6  //PB6
#define LED_PIN_0  PORTB &= ~(1<<LED_PIN)
#define LED_PIN_1  PORTB |= (1<<LED_PIN)
#define LED_PIN_TOGGLE PORTB ^= (1<<LED_PIN)

// ADC Channels
#define ADC_PRESCALER 4  //divide by 16 (1MHz ADC clock)

#define ADC_MUX_I       0x22  // ADC2+Bit 5 – ADLAR: ADC Left Adjust Result
#define ADC_MUX_W       0x24  // ADC4+Bit 5 – ADLAR: ADC Left Adjust Result
#define ADC_MUX_U       0x25  // ADC6+Bit 5 – ADLAR: ADC Left Adjust Result
#define ADC_MUX_V       0x26  // ADC5+Bit 5 – ADLAR: ADC Left Adjust Result

// Variables
#define VARIABLE_TABLE_SIZE  16  // number of bytes in table

// EEPROM
#define EEPROM_TABLE_SIZE  32  // number of bytes in table

// EEPROM
#define HEADER_SIZE  64  // number bytes (0xFF values) sent between data


//*****************************************************************************
// Tables (RAM)
//*****************************************************************************

uint8_t  adc_mux_table_forward[6] = 
  {
        ADC_MUX_V,
        ADC_MUX_U,
        ADC_MUX_W,
        ADC_MUX_V,
        ADC_MUX_U,
        ADC_MUX_W
  };


// Table of upper output patterns for forward driving.
uint8_t upper_comm_table_forward[6] = 
{
        UPPER_DRIVE_STEP2_CW,
        UPPER_DRIVE_STEP1_CW,
        UPPER_DRIVE_STEP6_CW,
        UPPER_DRIVE_STEP5_CW,
        UPPER_DRIVE_STEP4_CW,
        UPPER_DRIVE_STEP3_CW
};


// Table of lower output patterns for forward driving.
uint8_t lower_comm_table_forward[6] = 
{
        LOWER_DRIVE_STEP2_CW,
        LOWER_DRIVE_STEP1_CW,
        LOWER_DRIVE_STEP6_CW,
        LOWER_DRIVE_STEP5_CW,
        LOWER_DRIVE_STEP4_CW,
        LOWER_DRIVE_STEP3_CW
};


// Edge Level ZC for forward driving.
uint8_t zc_table_forward[6] =
{
        EDGE_RISING,
        EDGE_FALLING,
        EDGE_RISING,
        EDGE_FALLING,
        EDGE_RISING,
        EDGE_FALLING 
};


//*****************************************************************************
// Global Variables
//*****************************************************************************


// Loop Counter
uint8_t pwm_counter = 0;

uint8_t bit_test = 0;

// PWM output
uint16_t pwm_value;

// Commutation and Timer
uint8_t commutation_step = 0;
uint16_t comm_period;
uint16_t comm_period_temp;
uint16_t timer_capture;
uint16_t timer_capture_last;

// PWM input command
uint16_t pwm_cmd;
uint16_t pwm_cmd_next;
uint8_t pwm_cmd_updated;
uint16_t pwm_cmd_filter;
uint16_t pwm_cmd_filtered;

// Motor Commutation
// Commutation interrupt state 0 = update comm state, 1 = back EMF sample
uint8_t comm_inter_state; 

// ADC Samples
uint8_t bemf_sampled;
uint8_t adc_sample;
uint8_t get_bemf;       

// Back EMF Phase Locked Loop Compensation
uint16_t y0 = 0;             // Current Speed Count * 16
uint16_t y1 = 0;             // Last Speed Count * 16
uint16_t r0 = 0;             // Current Back EMF error voltage 
uint16_t nr0 = 0;            // Positive Compensation * 128
uint16_t r0_temp = 0;        // Current Back EMF error voltage 
uint16_t nr0_temp = 0;       // Positive Compensation * 128
uint16_t y0_min;             // Lower limit
uint16_t y0_max;             // Upper limit

//Speed Loop Compensation
uint16_t speed_cmd_calc;  // Calculated speed command
uint16_t slope;
uint16_t delta;
uint16_t intercept;
uint16_t s_y0 = 0;       // Speed Loop Count
uint16_t s_y1 = 0;       // Last Speed Loop Count
uint16_t s_r0 = 0;       // Current Speed Loop error voltage
uint16_t s_nr0 = 0;      // Current Speed Loop error voltage (negative)
uint16_t s_y0_min;       // lower limit
uint16_t s_y0_max;       // upper limit

//Communication Data
uint8_t comm_data;
uint8_t data_toggle;

//PWM Timer Back EMF Sampling variables
uint8_t adc_sample_state = 0; // 0 = current, 1 = current, 2 = v_bus,
        // 3 = Back EMF 
uint8_t bemf_ready = 0;   // 0 = not ready, 1 = ready
uint8_t commutation_step_sampled = 0;
uint16_t neutral_averaging;
uint8_t neutral = 0;

// Speed Loop counts
uint8_t s_loop_count = 0;

// Operation mode
uint8_t input_state = 1;    // 0 = PWM input, 1 = UART Data In
uint8_t output_state = 1;   // 0 = Tach output, 1 = UART Data Out
uint8_t control_state = 1;  // 0 = Speed Control, 1 = Open Loop PWM

// LED
uint16_t led_blink_count = 0;


// EEPROM Parameters
uint8_t valid_byte;
uint8_t eeprom_number;

uint8_t motor_kpv;
uint8_t motor_kiv;
uint8_t motor_max_speed;
uint8_t motor_norm_speed;
uint8_t motor_min_speed;

// Serial in
uint8_t bit_count_low;
uint8_t bit_position;
uint16_t bit_timeout;
uint16_t byte_timeout;
uint8_t data_in;

uint8_t motor_off;   // bit 0 = motor off command,
        // bit 1 = motor turned off, bit 2 = transfer variables back to EEPROM 
uint8_t pin_test;    //pin test for calibration

uint8_t count_dir;


// Counter for table operations
uint8_t table_counter = 0;

// Variable and EEPROM table
uint8_t variable_table[VARIABLE_TABLE_SIZE + EEPROM_TABLE_SIZE];

// Aliases for variables
#define command                 variable_table[0]

#define speed_cmd               variable_table[1]
#define speed                   variable_table[2]
#define speed_error             variable_table[3]

#define current_limit           variable_table[4]
#define current                 variable_table[5]

#define pwm_limit               variable_table[6]
#define pwm                     variable_table[7]

#define bemf                    variable_table[8]
#define bemf_error              variable_table[9]

#define v_bus                    variable_table[10]
#define v_motor                  variable_table[11]

#define osc_cal                 variable_table[12]
#define osc_error               variable_table[13]

#define data_rxd                variable_table[14]

#define counter                 variable_table[15]

// Aliases for EEPROM values
#define enable_voltage          variable_table[0 + VARIABLE_TABLE_SIZE] 
#define osc_cal_adj             variable_table[1 + VARIABLE_TABLE_SIZE] 
#define data_watch              variable_table[2 + VARIABLE_TABLE_SIZE]
#define mode                    variable_table[3 + VARIABLE_TABLE_SIZE]
#define input_cmd               variable_table[4 + VARIABLE_TABLE_SIZE]

#define speed_count_min         variable_table[5 + VARIABLE_TABLE_SIZE]
#define speed_count_max         variable_table[6 + VARIABLE_TABLE_SIZE]
#define r0_limit                variable_table[7 + VARIABLE_TABLE_SIZE] 
#define kp                      variable_table[8 + VARIABLE_TABLE_SIZE]
#define ki                      variable_table[9 + VARIABLE_TABLE_SIZE]
#define pll_gravity             variable_table[10 + VARIABLE_TABLE_SIZE]
#define pwm_min                 variable_table[11 + VARIABLE_TABLE_SIZE]
#define pwm_max                 variable_table[12 + VARIABLE_TABLE_SIZE]
#define s_loop_rate             variable_table[13 + VARIABLE_TABLE_SIZE]
#define s_r0_limit              variable_table[14 + VARIABLE_TABLE_SIZE]
#define s_kp                    variable_table[15 + VARIABLE_TABLE_SIZE]
#define s_ki                    variable_table[16 + VARIABLE_TABLE_SIZE]

#define speed_cmd_min           variable_table[17 + VARIABLE_TABLE_SIZE]
#define speed_cmd_max           variable_table[18 + VARIABLE_TABLE_SIZE]
#define speed_scale             variable_table[19 + VARIABLE_TABLE_SIZE]

#define current_limit_startup   variable_table[20 + VARIABLE_TABLE_SIZE]
#define current_limit_max       variable_table[21 + VARIABLE_TABLE_SIZE]
#define current_limit_slope     variable_table[22 + VARIABLE_TABLE_SIZE]

#define v_bus_min                variable_table[23 + VARIABLE_TABLE_SIZE]

#define command_0               variable_table[24 + VARIABLE_TABLE_SIZE]
#define speed_cmd_0             variable_table[25 + VARIABLE_TABLE_SIZE]
#define command_1               variable_table[26 + VARIABLE_TABLE_SIZE]
#define speed_cmd_1             variable_table[27 + VARIABLE_TABLE_SIZE]
#define command_2               variable_table[28 + VARIABLE_TABLE_SIZE]
#define speed_cmd_2             variable_table[29 + VARIABLE_TABLE_SIZE]
#define command_3               variable_table[30 + VARIABLE_TABLE_SIZE]
#define speed_cmd_3             variable_table[31 + VARIABLE_TABLE_SIZE]


//*****************************************************************************
// initialize TACH/Alarm PA0 as output low
//***************************************************************************** 

void intTACH(void)
{
        PORTA &= ~(1<<TACH_PIN);   // set PA0 low
        DDRA |= (1<<TACH_PIN);     // make PA0 an output 
}


//*****************************************************************************
// initialize Test pin
//***************************************************************************** 

void intTestPin(void)
{
        PORTA &= ~(1<<TEST_PIN);
        DDRA |= (1<<TEST_PIN);
}


//*****************************************************************************
// initialize LED pin
//***************************************************************************** 

void intLEDPin(void)
{
        PORTB &= ~(1<<LED_PIN);
        DDRB |= (1<<LED_PIN);
}


//*****************************************************************************
// initialize Timer 0 as Normal, 16-bit mode
//***************************************************************************** 

void intTimer0(void)
{
        // Set up Timer/counter0 
        TCCR0A = (1<<TCW0);  // Normal, 16-bit mode
        TCCR0B = (1<<CS01);  // Clk/8 Prescaler for 2MHz timer clock
}


//*****************************************************************************
// initialize PWM on Timer1
//***************************************************************************** 

void intPWM(void)
{
        //Clear on up-counting.
        TCCR1A = (1 << COM1A1) | (0 << COM1A0) | (1 << PWM1A);

        //Set WGM to PWM6, dual slope mode.
        TCCR1D = (1 << WGM11) | (1 << WGM10);

        // 16MHz/2/19200 = 417 counts, 0 to 416 (pwm + pwm>>1 + pwm>>3 + + pwm>>6)
        // (255+127+31+3)
        TC1H = 1;               //
        OCR1C = 0xA0;   //416 TOPVALUE (pwm + pwm>>1 + pwm>>3 + + pwm>>6)
        // (255+127+31+3)
        
        TCCR1B = (1 << CS10); //Prescaler 16MHz clock /1 = 16MHz
        
        //Set PWM pins as output.
        // (PWM output is still controlled through TCCR1E register.)
        DDRB = (1 << UL)|(1 << UH)|(1 << VL)|(1 << VH)|(1 << WL)|(1 << WH);
}


//*****************************************************************************
// initialize ADC PA1(ADC1),PA5(ADC4),PA6(ADC5),PA7(ADC6)
//***************************************************************************** 

void intADC(void)
{
        //PA1(ADC1)-DIR,PA5(ADC4)-THR,PA6(ADC5)-IB,PA7(ADC6)-IA,
        //PB6(ADC9)-V+,PB7(ADC10)-TEMP

        //ADMUX – ADC Multiplexer Selection Register
        //Bits 7:6 – REFS1:REFS0: Voltage Reference Selection Bits 00= Vcc
        //Bit 5 – ADLAR: ADC Left Adjust Result
        //Bits 4:0 – MUX4:0: Analog Channel and Gain Selection Bits
        ADMUX = ADC_MUX_I;

        //ADCSRA – ADC Control and Status Register A
        //Bit 7 – ADEN: ADC Enable
        //Bit 6 – ADSC: ADC Start Conversion
        //Bit 5 – ADATE: ADC Auto Trigger Enable
        //Bits 2:0 – ADPS2:0: ADC Prescaler Select Bits
        ADCSRA = ((1<<ADEN) | (1<<ADATE) | ADC_PRESCALER);
        
        //ADCL an ADCH – The ADC Data Register
        //read just ADCH for 8 bit values
                
        //ADCSRB – ADC Control and Status Register B
        //Timer/Counter1 Overflow - ADTS2 = 1, ADTS1 = 1, ADTS0 = 0
        ADCSRB = ((1<<ADTS2) | (1<<ADTS1));
        
        //DIDR0 – Digital Input Disable Register 0
        //Bits 7:4,2:0 – ADC6D:ADC0D: ADC6:0 Digital Input Disable
        //Bit 3 – AREFD: AREF Digital Input Disable
        DIDR0 |= ((1<<ADC2D)|(1<<ADC4D)|(1<<ADC5D)|(1<<ADC6D));
        
// ADATE in ADCSRA -  Auto Triggering is enabled by setting
// the ADC Auto Trigger Enable bit

// ADTS in ADCSRB - The trigger source is selected by setting
// the ADC Trigger Select bits
}



//*****************************************************************************
// Read in EEPROM values
//***************************************************************************** 

void read_eeprom(void)
{
        table_counter = 0;
        while (table_counter < EEPROM_TABLE_SIZE)
        {
                
                variable_table[VARIABLE_TABLE_SIZE + table_counter]=
                        eeprom_read_byte((uint8_t*)(table_counter));
                table_counter++;
        }
        table_counter = 0;
}


//*****************************************************************************
// write EEPROM values
//***************************************************************************** 

void write_eeprom(void)
{
        cli();
        table_counter = 0;
        while (table_counter < EEPROM_TABLE_SIZE)
        {
                eeprom_write_byte ((uint8_t*)(table_counter),
                        variable_table[VARIABLE_TABLE_SIZE + table_counter]);
                table_counter++;
        }
        table_counter = 0;
//      update_limits();
        motor_off = 0;
        sei();
}


//*****************************************************************************
// test oscillator calibration
//***************************************************************************** 

void test_oscillator(void)
{
        cli();
        //PC sends stream of 0 bytes at 19200 baud, for a 468.75us period
        
        OCR0B = 0xFF; 
        OCR0A = 0xFF; 
        
        //Capture timer period 
        pin_test = CMD_PIN_TEST;
        while (pin_test == CMD_PIN_1)   //wait while pin is high
        {
                pin_test = CMD_PIN_TEST;
        }
        
//      TEST_PIN_0;     
        
        pin_test = CMD_PIN_TEST;
        while (pin_test == CMD_PIN_0)   //wait while pin is low
        {
                pin_test = CMD_PIN_TEST;
        }

        TEST_PIN_1;

        pin_test = CMD_PIN_TEST;
        while (pin_test == CMD_PIN_1)   //wait while pin is high
        {
                pin_test = CMD_PIN_TEST;
        }

        //Capture timer value
        TCNT0H = 0;
        TCNT0L = 0;

//      TEST_PIN_0;     

        pin_test = CMD_PIN_TEST;
        while (pin_test == CMD_PIN_0)   //wait while pin is low
        {
                pin_test = CMD_PIN_TEST;
        }
        //Capture timer value again
        comm_period = TCNT0L;
        comm_period += (TCNT0H<<8);

//      TEST_PIN_1;     
        //At 2us per count period and a period of 468.75us the count should be 234.
        osc_error = comm_period + 128 - 833;
        motor_off = 0;
        
//      TEST_PIN_0;
        
        sei();
}


//*****************************************************************************
// Enable Interrupts
//***************************************************************************** 

void intInterrupts(void)
{
        cli();
        //TIMSK – Timer/Counter1 Interrupt Mask Register
        //Bit 4 – OCIE0A: Timer/Counter0 Output Compare Match A Interrupt Enable
        TIMSK |= (1<<OCIE0A);
        //Bit 2 – TOIE1: Timer/Counter1 Overflow Interrupt Enable
        TIMSK |= (1<<TOIE1);
        //Bit 3 – ADIE: ADC Interrupt Enable
        ADCSRA |= (1<<ADIE);   //Bit 3 – ADIE: ADC Interrupt Enable
        sei();
}


//*****************************************************************************
// ADC Interrupt - Triggered off of TOV1
//***************************************************************************** 

ISR(ADC_vect)
{
        TEST_PIN_1;
        if(adc_sample_state == 0 )
        {
                current = ADCH;
                ADMUX = adc_mux_table_forward[commutation_step];
                commutation_step_sampled = commutation_step;
                adc_sample_state = 1;
                
        }
        else
        {
                bemf_sampled = ADCH;
        
                if (get_bemf)
                {
                        
                        if (commutation_step_sampled == commutation_step)
                        {
                                bemf = bemf_sampled;
                                neutral_averaging = (neutral_averaging - neutral) + bemf; 
                                v_bus = neutral_averaging>>5;
                                neutral = v_bus>>1;
                                if (pwm < 20)
                                {
                                        // Below 20 counts sample window is too small
                                        v_bus = neutral;
                                }

                                bemf_ready = 1;
                                // Increasing Back EMF
                                if (zc_table_forward[commutation_step_sampled] == 0)
                                {
                                        if (bemf <= neutral)  // Too Fast
                                        {
                                                r0_temp = 0;
                                                nr0_temp = neutral - bemf;
                                        }
                                        else   // Too Slow
                                        {
                                                r0_temp = bemf - neutral;
                                                nr0_temp = 0;
                                        }
                                }
                                else
                                {
                                        if (bemf <= neutral)  // Too Slow
                                        {
                                                r0_temp = neutral - bemf;
                                                nr0_temp = 0;
                                        }
                                        else  // Too Fast
                                        {
                                                r0_temp = 0;
                                                nr0_temp = bemf - neutral;
                                        }
                                }
                        }
                        get_bemf = 0;
                }
                
                ADMUX = ADC_MUX_I;
                adc_sample_state = 0;
        }       
        
        TEST_PIN_0;
}


//*****************************************************************************
// Timer1 PWM Interrupt - Center of PWM period
//***************************************************************************** 

ISR(TIMER1_OVF_vect)
{
        TEST_PIN_1;
        if (CMD_PIN_TEST == CMD_PIN_1)
        {
                pwm_cmd_next++;
                if (bit_position > 0)
                {
                        byte_timeout=0;
                        bit_timeout++;
                        if (bit_timeout > 1920) //100ms
                        {
                                bit_position = 0;
                        }
                }
                else
                {
                        bit_timeout = 0;
                }
                
                byte_timeout++;
                if((bit_count_low > 6)&&(bit_count_low < 10)) // 7, 8, or 9 PWM periods
                {
                        data_in = 0;
                        bit_position++;
                        bit_timeout = 0;
                }
                if((bit_count_low > 2)&&(bit_count_low < 6)) // 3, 4, or 5 PWM periods
                {
                        data_in = 1;
                        bit_position++;
                        bit_timeout = 0;
                }
                bit_count_low = 0;
        }
        else
        {
                bit_count_low++;
                if (bit_count_low > 9)
                {
                        bit_count_low = 10;
                        bit_position = 0;
                }
        }       
        if (pwm_counter == 0)
        {
                pwm_cmd = pwm_cmd_next;
                pwm_cmd_next = 0;
                pwm_cmd_updated = 1;
        }
        pwm_counter++;


        if (input_state == 1)
        {
                //Serial Data in (sort of) looking for 4 PWMs low = 1 and
                // 8 PWMs low = 0 only when UART receive enabled

                if (bit_position == 1)
                {
                        data_rxd = 0;  //valid start bit
                }
                if ((bit_position > 0)&&(bit_position < 9))
                {
                        data_rxd |= data_in<<(bit_position-1);
                }       
                if (bit_position == 8)
                {
                        valid_byte++;
                        bit_position = 0;  //start over
                }

                if ( byte_timeout >= 19200)  //29200/19200Hz = 1sec
                {
                        valid_byte=0;
                        byte_timeout=0;
                }

                if (valid_byte == 3)
                {
                        if (eeprom_number < EEPROM_TABLE_SIZE)
                        {
                                variable_table[eeprom_number + VARIABLE_TABLE_SIZE] = data_rxd;
                        }
                
                        valid_byte=0;
                        if ((eeprom_number == 254)&(data_rxd == 254))
                        {
                                motor_off = 5;//Motor off command and variables ready for write
                        }
                        if ((eeprom_number == 255)&(data_rxd == 255))
                        {
                                motor_off = 9; // Motor off command and calibrate oscillator
                        }                               
                }
                
                if (valid_byte == 1)
                {
                        eeprom_number = data_rxd;
                        valid_byte++;
                }
        }       
        else
        {
                valid_byte=0;
                byte_timeout=0;
        }
        
        // Software UART Transmit here
        if (output_state == 1)
        {
                if ((pwm_counter & 0x0F) == 0)
                {
                        TACH_PIN_0;  //Start Bit
                }       
                else
                {
                        if ((pwm_counter & 0x0F) < 9)
                        {
                                if (comm_data & 0x01)   //LSB first
                                {
                                        TACH_PIN_1;             // TXD = 1
                                }
                                else
                                {
                                        TACH_PIN_0;         // TXD = 0 
                                }

                                comm_data = comm_data>>1;
                        }
                        else
                        {
                                TACH_PIN_1;
                        }
                }
        }
        TEST_PIN_0;
}


//*****************************************************************************
// Interrupt Timer0 
//***************************************************************************** 

ISR(TIMER0_COMPA_vect)
{
        TEST_PIN_1;
        if (comm_inter_state == 1) // back EMF sampling
        {
                get_bemf = 1;
                comm_inter_state = 0; // Update Commutation on next interrupt
        }

        else  // update commutation state 
        {
                commutation_step++;
                if (commutation_step>=6)
                {
                        commutation_step=0;
                }
                // Update commutation state
                TCCR1E = lower_comm_table_forward[commutation_step];
                PORTB &=  ~(UPPER_DRIVE_MASK);
                PORTB |= upper_comm_table_forward[commutation_step];
                
                if (output_state == 0) //Only update on proper commutation state edge
                {
                        if (commutation_step == 0)
                        {
                                TACH_PIN_0;
                        }
                        if (commutation_step == 3)
                        {
                                TACH_PIN_1;
                        }
                } 
                comm_inter_state = 1; // Back EMF sample on next interrupt
        }

        // Update Timer Compare Value
        timer_capture = timer_capture_last + comm_period;
        OCR0B = (timer_capture >> 8); 
        OCR0A = timer_capture; 
        timer_capture_last = timer_capture;

        TEST_PIN_0;

}


//*****************************************************************************
// Main
//*****************************************************************************

int main(void)
{
        intPWM();               // Initialize timer1 as PWM6 mode center aligned
        intTimer0();            // Initialize timer0 for commutation timing
        intTACH();              // Initialize I/O pin as tachometer out
        intTestPin();           // Initialize I/O pin as test pin
        intLEDPin();            // Initialize I/O pin as LED indicator
        intADC();               // Initialize ADC
        read_eeprom();          // Read the EEPROM contents once on power up
        intInterrupts();        // Enable interrupts
        
        osc_cal = OSCCAL;       // Read the factory calibration once on power up

    while(1)
    {
                
                led_blink_count++;
                if (led_blink_count >= comm_period_temp)
                {
                        LED_PIN_TOGGLE;
                        led_blink_count = 0;
                }

                //Recalculated limits in case they have changed from
                // Fan Configuration Utility
                y0_min = ((speed_count_min<<LOOP_SCALING) + HALF_LIMIT);
                y0_max = ((speed_count_max<<LOOP_SCALING) + HALF_LIMIT);
                s_y0_min = ((pwm_min<<LOOP_SCALING) + HALF_LIMIT);
                s_y0_max = ((pwm_max<<LOOP_SCALING) + HALF_LIMIT);
                        
                // Compare DC input voltage (V_bus) with enable_voltage,
                // below threshold use defaults
                if (v_bus <= enable_voltage)
                {
                        input_state = 1;      //0 = pwm input, 1 = UART Data In
                        output_state = 1;     //0 = Tach output, 1 = UART Data Out
                        control_state = 1;    //0 = Speed Control, 1 = Open Loop PWM
                        OSCCAL = osc_cal;
                }
                else
                {
                        input_state = (mode & 0x01);       //0 = PWM input,
                        // 1 = UART Data In
                        output_state = (mode & 0x02)>>1;   //0 = Tach output,
                        // 1 = UART Data Out
                        control_state = (mode & 0x04)>>2;  //0 = Speed Control,
                        // 1 = Open Loop PWM
                        if (osc_cal_adj < 33)
                        {
                                OSCCAL = osc_cal + osc_cal_adj - 16;
                        }
                        else
                        {
                                OSCCAL = osc_cal;
                        }       
                }
                
                // Wait here for 16 PWM periods to pass -
                // Timing for control loop 19200Hz/16 = 1200Hz (833us)
                cli();
                bit_test = (pwm_counter & 0x0F);
                sei();
                while(bit_test != 0x0F)
                {
                        cli();
                        bit_test = (pwm_counter & 0x0F);
                        sei();
                }
                cli();
                bit_test = (pwm_counter & 0x0F);
                sei();
                while(bit_test > 0)
                {               
                        cli();
                        bit_test = (pwm_counter & 0x0F);
                        sei();
                }

                // Calculate Motor Voltage
                v_motor = (v_bus*pwm)>>8;

                // Write EEPROM function here. Non-reentrant so must disable interrupts 
                if (motor_off == 7)   // bit 0 = motor off command,
                // bit 1 = motor turned off, bit 2 = transfer variables back to EEPROM,
                // bit 3 = Cal Oscillator
                {
                                write_eeprom();
                }
                if (motor_off == 11)   // bit 0 = motor off command,
                // bit 1 = motor turned off,
                // bit 2 = transfer variables back to EEPROM bit 3 = Cal Oscillator 
                {
                                test_oscillator();
                }

                // Serial Data Selection
                if (data_toggle)
                {
                        if (table_counter < (VARIABLE_TABLE_SIZE + EEPROM_TABLE_SIZE))
                        {
                                comm_data = variable_table[table_counter];
                        }
                        else
                        {
                                if (table_counter == (VARIABLE_TABLE_SIZE + EEPROM_TABLE_SIZE))
                                {
                                        comm_data = 0;      // 0 at end of data
                                }
                                else
                                {
                                        comm_data = 255;    // The rest of the data is 255s
                                }
                                
                        }
                        table_counter++;
                        if (table_counter > (HEADER_SIZE + VARIABLE_TABLE_SIZE +
                                 EEPROM_TABLE_SIZE + 1))
                        {               
                                table_counter = 0;
                                comm_data = 0;    // 0 at beginning of data
                                
                        }
                        data_toggle = 0;
                }
                else
                {
                        
                        if (count_dir == 0)
                        {
                                counter++;
                                if (counter>254)
                                {
                                        count_dir = 1;
                                }
                        }
                        else
                        {
                                counter--;
                                if (counter<1)
                                {
                                        count_dir = 0;
                                }
                        }
                        
                        comm_data = variable_table[data_watch];
                        if (comm_data > 254)
                        {
                                comm_data = 254; // Clip data at 254
                        }
                        data_toggle = 1;
                }


                // PWM input (Speed command) averaging filter
                if (pwm_cmd_updated == 1)
                {
                        pwm_cmd_updated = 0;
                        pwm_cmd_filter = (pwm_cmd_filter - pwm_cmd_filtered) + pwm_cmd;
                        pwm_cmd_filtered = pwm_cmd_filter>>6;
                        if (pwm_cmd_filtered > 255)
                        {
                                pwm_cmd_filtered = 255;
                        }
                }


                // Check to see where command comes from either
                // Fan Configuration Utility of PWM input (Speed command)
                if (input_state == 1)
                {
                        command = input_cmd;
                }
                else
                {
                        command = pwm_cmd_filtered;
                }


                // Back EMF Sensing PLL Update
                if (bemf_ready == 1)
                {

                        cli();
                        bemf_ready = 0;
                        r0=r0_temp;
                        nr0=nr0_temp;
                        sei();
                
                        // Back EMF sensing PLL PI regulator
                        if(r0>r0_limit)
                        {
                                r0=r0_limit;
                        }
                        if(nr0>r0_limit)
                        {
                                nr0=r0_limit;
                        }               

                        nr0 += pll_gravity;
                        
                        bemf_error = 128 + r0 - nr0;
                        
                        y1 += ((r0*ki)>>8);    // ki
                        y1 -= ((nr0*ki)>>8);   // ki
                
                        if (y1 < y0_min)
                        {
                                y1 = y0_min; 
                        }
                        if (y1 > y0_max)
                        {
                                y1 = y0_min;      // Restart PLL
                        }
                        
                        y0 = y1 + ((r0*kp)>>8) - ((nr0*kp)>>8);   // kp
                        
                        if (y0 < y0_min)
                        {
                                y0 = y0_min; 
                        }
                        if (y0 > y0_max)
                        {
                                y0 = y0_min;    // Restart PLL
                        }                       
                        
                        if (speed_cmd < speed_cmd_min)
                        {
                                y1 = y0_min;    // Restart PLL
                        }
                
                        speed = (y0 - HALF_LIMIT) >> LOOP_SCALING;

                        comm_period_temp = (0xFFFF/speed)>>speed_scale;

                        cli();
                        comm_period = comm_period_temp;
                        sei();
                }
        

                // Speed Control Loop Update
                s_loop_count++;
                if (s_loop_count >= s_loop_rate)
                {
                        s_loop_count = 0;
                        // Speed command Mapping 
                        
                        if (command > command_3)
                        {
                                slope = 255 - speed_cmd_3;
                                delta = command - command_3;
                                intercept = speed_cmd_3;
                        }
                        else
                        {
                                if (command > command_2)
                                {
                                        slope = speed_cmd_3 - speed_cmd_2;
                                        delta = command - command_2;
                                        intercept = speed_cmd_2;        
                                }
                                else
                                {
                                        if (command > command_1)
                                        {
                                                slope = speed_cmd_2 - speed_cmd_1;
                                                delta = command - command_1;
                                                intercept = speed_cmd_1;
                                        }
                                        else
                                        {
                                                if (command > command_0)
                                                {
                                                        slope = speed_cmd_1 - speed_cmd_0;
                                                        delta = command - command_0;
                                                        intercept = speed_cmd_0;
                                                }
                                                else
                                                {
                                                        slope = 0;
                                                        delta = 0;
                                                        intercept = 0;
                                                }
                                        }
                                }
                        }
                        
                        speed_cmd_calc = ((slope*delta)/255) + intercept;

//                      speed_cmd = command; //Linear Mapping for testing purposes
                                
                        if (speed_cmd_calc > speed_cmd_max)
                        {
                                speed_cmd_calc = speed_cmd_max;
                        }
                        
                        if (speed_cmd_calc < speed_cmd_min)
                        {
                                speed_cmd_calc = speed_cmd_min;
                        }
                        
                        speed_cmd = speed_cmd_calc;
                        
                        // Speed Control PI regulator
                        if (speed > speed_cmd)
                        {
                                s_nr0 = speed - speed_cmd;
                                s_r0 = 0;
                        }
                        else
                        {
                                s_r0 = speed_cmd - speed;
                                s_nr0 = 0; 
                        }

                        if(s_nr0>s_r0_limit)
                        {
                                s_nr0=s_r0_limit;
                        }
                        if(s_r0>s_r0_limit)
                        {
                                s_r0=s_r0_limit;
                        }               


                        speed_error = 128 - s_r0 - s_nr0;

                        s_y1 += ((s_r0*s_ki)>>6);   //s_ki
                        s_y1 -= ((s_nr0*s_ki)>>6);  //s_ki
                        
                        if (s_y1 < s_y0_min)
                        {
                                s_y1 = s_y0_min; 
                        }
                        if (s_y1 > s_y0_max)
                        {
                                s_y1 = s_y0_max;
                        }
                        
                        s_y0 = s_y1 + ((s_r0*s_kp)>>6) - ((s_nr0*s_kp)>>6); //s_kp 
                        
                        if (s_y0 < s_y0_min)
                        {
                                s_y0 = s_y0_min; 
                        }
                        if (s_y0 > s_y0_max)
                        {
                                s_y0 = s_y0_max;
                        }                       
        
                        pwm = (s_y0 - HALF_LIMIT) >> LOOP_SCALING;
                }

                // Open Loop PWM or Speed Control
                if (control_state == 1)  // Direct PWM command for testing purposes
                {
                        
                        if (command>pwm_max)
                        {
                                pwm = pwm_max;
                        }
                        else
                        {
                                pwm = command;
                                if (pwm < pwm_min)
                                {
                                        pwm = pwm_min;
                                }
                        }
                }                       

                // Current limiting
                if (speed < speed_cmd_min )
                {       
                        // Lower Current limit gives better startup performance
                        current_limit = current_limit_startup;
                }
                else   //Higher current limit for high speed operation
                {
                        current_limit = current_limit_startup + 
                                ((((speed - speed_cmd_min)*current_limit_slope)>>8));
                        if (current_limit > current_limit_max)
                        {
                                // upper current limit for high power operation
                                current_limit = current_limit_max;
                        }
                }
                
                // Folds back PWM when exceeding current limit
                if (current > current_limit)
                {
//                      TEST_PIN_1;
                        if (pwm_limit > 1)
                        {
                                pwm_limit--;
                        }
                }
                else
                {
                        if (pwm_limit < pwm)
                        {
                                pwm_limit++;
                        }
                }       

                if (pwm > pwm_limit)
                {
                        pwm = pwm_limit;
                }

                // Minimum DC Bus Voltage before enabling
                // back EMF sensing and speed control
                if (v_bus < v_bus_min)
                {
                        pwm = pwm_min;
                        s_y1 = s_y0_min;   // Reset Integrator
                        s_y0 = 0;          // PWM off
                        y1 = y0_min;       // Restart PLL
                }
                
                // Motor Off function for updating EEPROM 
                if (motor_off == 0)
                {
                        // 16MHz/2/19200 = 417 counts, 0 to 416 
                        // (pwm + pwm>>1 + pwm>>3 + + pwm>>6) (255+127+31+3)
                        pwm_value = pwm + (pwm>>1) + (pwm>>3) + (pwm>>6);
                        cli();
                        TC1H = (pwm_value >> 8); 
                        OCR1A = pwm_value;
                        sei();
                }
                else
                {
                        cli();
                        TC1H = 0; 
                        OCR1A = 0;
                        motor_off |= 2;  // Motor PWM at zero
                        sei();
                        //pwm = pwm_min;
                        s_y1 = s_y0_min;   // Reset Integrator
                        s_y0 = 0;          // PWM off
                        y1 = y0_min;       // Restart PLL
                }

    }
}